//package com.yunhe.device.service.device.impl;
//
//import com.yunhe.common.util.StringUtil;
//import com.yunhe.device.domain.base.PointDataType;
//import com.yunhe.device.domain.device.Analog;
//import com.yunhe.common.exception.ArgumentErrorException;
//import com.yunhe.common.exception.DatabaseProcessException;
//import com.yunhe.common.exception.ObjectNotFoundException;
//import com.yunhe.common.exception.UniqueConstraintsException;
//import com.yunhe.device.repository.authority.ResourceTreeRepository;
//import com.yunhe.device.repository.device.AnalogRepository;
//import com.yunhe.device.repository.device.impl.AnalogDao;
//import com.yunhe.device.service.base.PointDataTypeService;
//import com.yunhe.device.service.device.AnalogService;
//import com.yunhe.device.service.device.ModelService;
//import org.apache.commons.lang3.StringUtils;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.annotation.Transactional;
//
//import java.util.*;
//
///**
// * 点表Service
// * @desc 点表服务类实现
// * @author liuronglei
// */
//@Service
//public class AnalogServiceImpl implements AnalogService {
//    @Autowired
//    private ModelService modelService;
//    @Autowired
//    private AnalogRepository analogRepository;
//    @Autowired
//    private PointDataTypeService pointDataTypeService;
//    @Autowired
//    private ResourceTreeRepository resourceTreeRepository;
//    @Autowired
//    private AnalogDao analogDao;
//
//    /**
//     * 点表对象处理和判断
//     * @param analog 点表对象
//     */
//    private void processBeforeSave(Analog analog)
//            throws ArgumentErrorException, UniqueConstraintsException {
//        //判断代码是否为空
//        Long devCode = analog.getDevCode();
//        Long typeCode = analog.getTypeCode();
//        if (analog.getCode() == null || devCode == null || typeCode == null) {
//            throw new ArgumentErrorException("点表代码、设备代码、点号数据类型代码不能为空");
//        }
//        //判断设备是否存在,判断设备是否唯一
//        int devListSize = analogRepository.findDevByDevCode(devCode).size();
//        if (devListSize == 0) {
//            throw new ArgumentErrorException("代码为" + devCode + "的设备不存在");
//        } else if (devListSize > 1) {
//            throw new UniqueConstraintsException("代码为" + devCode +"的设备不唯一");
//        }
//        //判断点号数据类型是否存在
//        if (pointDataTypeService.findByCode(typeCode) == null) {
//            throw new ArgumentErrorException("代码为" + typeCode + "的点号数据类型不存在");
//        }
//        //判断代码是否已存在
//        Analog analogByCode = this.findByCode(analog.getCode());
//        if (analogByCode != null) {
//            if (analog.getId() == null || analogByCode.getId().longValue() != analog.getId().longValue()) {
//                throw new UniqueConstraintsException("代码为" + analog.getCode() + "的点表已存在");
//            }
//        }
//        //判断是否已绑定该数据类型的点表
//        Analog analogByTypeCode = analogRepository.findAnalogsByDevCodeAndTypeCode(analog.getDevCode(), analog.getTypeCode());
//        if (analogByTypeCode != null) {
//            if (analog.getId() == null || analogByTypeCode.getId().longValue() != analog.getId().longValue()) {
//                throw new UniqueConstraintsException("设备" + analog.getDevCode() + "已存在数据类型为" + analog.getTypeCode() + "的点号");
//            }
//        }
//    }
//
//    /**
//     * 新增点表
//     * @param analog 点表对象
//     */
//    @Override
//    @Transactional
//    public Analog createAnalog(Analog analog)
//            throws ArgumentErrorException, UniqueConstraintsException {
//        analog.setId(null);
//        processBeforeSave(analog);
//        Long pointDataTypeCode = analog.getTypeCode();
//        Long devCode = analog.getDevCode();
//        String terminal = analog.getTerminal();
//        analog.setDevCode(null);
//        analog.setTypeCode(null);
//        analog.setTerminal(null);
//        Analog newAnalog = analogRepository.save(analog);
//        analogRepository.bindPointDataTypeByCode(newAnalog.getCode(), pointDataTypeCode);
//        analogRepository.bindDev(newAnalog.getCode(), devCode, terminal);
////        resourceTreeRepository.bindResourceByFirmCode(firmCode, "Analog", newAnalog.getId());
////        svgCode.ifPresent(value -> modelService.addLabel(newAnalog.getId(), value));
//        newAnalog.setDevCode(devCode);
//        newAnalog.setTypeCode(pointDataTypeCode);
//        newAnalog.setTerminal(terminal);
//
//        if (StringUtils.isNotEmpty(analog.getOfficeName())) {
//            analogRepository.bindOfficeByOfficeName(analog.getOfficeName(), analog.getCode());
//        }
//
//        return newAnalog;
//    }
//
//    /**
//     * 批量新增点表
//     * @param list 点表列表
//     */
//    @Override
//    @Transactional
//    public Iterable<Analog> createAnalog(List<Analog> list)
//            throws ArgumentErrorException, UniqueConstraintsException {
//        List<Analog> newAnalogList = new ArrayList<>();
//        for (Analog analog : list) {
//            newAnalogList.add(createAnalog(analog));
//        }
//        return newAnalogList;
//    }
//
//    /**
//     * 根据ID删除点表
//     * @param id 点表ID
//     */
//    @Override
//    @Transactional
//    public void deleteAnalog(Long id) {
//        analogRepository.deleteById(id);
//    }
//
//    /**
//     * 根据点号删除点表记录
//     * @param pointNumber 点号
//     */
//    @Override
//    @Transactional
//    public Long deleteAnalogByPointNumber(Long pointNumber) {
//        return analogRepository.deleteByPointNumber(pointNumber);
//    }
//
//    /**
//     * 根据设备ID和类型ID删除点表记录
//     * @param devCode 设备代码
//     * @param typeCode 点号数据类型代码
//     */
//    @Override
//    @Transactional
//    public Long deleteAnalogByDevCodeAndTypeCode(Long devCode, Long typeCode) {
//        return analogRepository.deleteByDevCodeAndTypeCode(devCode, typeCode);
//    }
//
//    /**
//     * 根据代码删除点表记录
//     * @param code 代码
//     */
//    @Override
//    @Transactional
//    public void deleteAnalogByCode(Long code) {
//        analogRepository.deleteByCode(code);
//    }
//
//    /**
//     * 修改点表
//     * @param code 点表代码
//     * @param analog 要更新的点表对象
//     * @return
//     */
//    @Override
//    @Transactional
//    public Analog updateAnalog(Long code, Analog analog)
//            throws ArgumentErrorException, UniqueConstraintsException, ObjectNotFoundException {
//        Analog analogByCode = analogRepository.findAnalogByCode(code);
//        if (analogByCode == null) {
//            throw new ObjectNotFoundException("找不到code为" + analog.getCode() + "的点表");
//        }
//        analog.setId(analogByCode.getId());
//        analog.setCode(code);
//        processBeforeSave(analog);
//        Long devCode = analog.getDevCode();
//        Long pointDataTypeCode = analog.getTypeCode();
//        String terminal = analog.getTerminal();
//        analogRepository.deleteAnalogByDevCode(analog.getCode());
//        analog.setId(null);
//        analog.setDevCode(null);
//        analog.setTypeCode(null);
//        analog.setTerminal(null);
//        Analog newAnalog = analogRepository.save(analog);
//        if (terminal != null) {
//            analogRepository.bindDev(newAnalog.getCode(), devCode, terminal);
//        } else {
//            analogRepository.bindDev(newAnalog.getCode(), devCode, null);
//        }
//        if (pointDataTypeCode != null) {
//            analogRepository.bindPointDataTypeByCode(newAnalog.getCode(), pointDataTypeCode);
//        } else {
//            throw new ArgumentErrorException("点号数据类型代码不能为空");
//        }
//        if (StringUtils.isNotEmpty(analog.getOfficeName())) {
//            analogRepository.bindOfficeByOfficeName(analog.getOfficeName(), code);
//        }
//        return newAnalog;
//    }
//
//    /**
//     * 更新点表记录
//     * @param analogId id
//     * @param name 编号
//     * @param code 代码
//     * @param pathName 路径
//     * @param devCode 设备代码
//     * @param typeCode 点号数据类型代码
//     * @param pointNumber 点号
//     * @param transformRatio 倍率
//     */
//    @Override
//    @Transactional
//    public Analog updateAnalog(Long analogId,
//                               String name,
//                               Long code,
//                               String pathName,
//                               Long devCode,
//                               Long typeCode,
//                               Long pointNumber,
//                               Double transformRatio)
//            throws ArgumentErrorException, ObjectNotFoundException, UniqueConstraintsException {
//        Analog analog = this.findByAnalogId(analogId);
//        if (analog == null) {
//            throw new ObjectNotFoundException("找不到ID为" + analogId + "的点表");
//        }
//        Optional.ofNullable(code).ifPresent(analog::setCode);
//        Optional.ofNullable(name).ifPresent(analog::setName);
//        Optional.ofNullable(pathName).ifPresent(analog::setPathName);
//        Optional.ofNullable(devCode).ifPresent(analog::setDevCode);
//        Optional.ofNullable(typeCode).ifPresent(analog::setTypeCode);
//        Optional.ofNullable(pointNumber).ifPresent(analog::setPointNumber);
//        Optional.ofNullable(transformRatio).ifPresent(analog::setTransformRatio);
//        processBeforeSave(analog);
//        return analogRepository.save(analog);
//    }
//
//    /**
//     * 根据ID获得点表记录
//     * @param id id
//     */
//    @Override
//    public Analog findByAnalogId(Long id) {
//        return analogRepository.findById(id).orElse(null);
//    }
//
//    /**
//     * 根据代码获得点表记录
//     * @param code 代码
//     */
//    @Override
//    public Analog findByCode(Long code) {
//        return analogRepository.findAnalogByCode(code);
//    }
//
////    /**
////     * 获得所有点表记录（根据单位代码）
////     */
////    public Iterable<Analog> findAnalogs(Long firmCode) {
////        if (QueryUtil.needPaging(pageParam)) {
////                int size = pageParam.getSize();
////                int page = pageParam.getPage();
////                List<String> sort = pageParam.getSort();
////            return analogRepository.findAnalogs(page, size);
////        } else {
////            Sort sort = QueryUtil.getSort(pageParam.getSort());
////            if (sort != null) {
////                return analogRepository.findAll(sort);
////            } else {
////                return analogRepository.findAll();
////            }
////            return analogRepository.findAnalogs();
////        }
////        return analogRepository.findAnalogs(firmCode);
////    }
//
//    /**
//     * 获得所有点表记录
//     */
//    @Override
//    public Iterable<Analog> findAnalogs() {
//        return analogRepository.findAnalogs();
//    }
//
//    /**
//     * 根据点号获得所有点表记录
//     * @param pointNumber 点号
//     */
//    @Override
//    public Iterable<Analog> findAnalogsByPointNumber(Long pointNumber) {
////        if (QueryUtil.needPaging(pageParam)) {
////            return analogRepository.findByPointNumber(pointNumber, QueryUtil.getPageRequest(pageParam));
////        } else {
////            Sort sort = QueryUtil.getSort(pageParam.getSort());
////            if (sort != null) {
////                return analogRepository.findByPointNumber(pointNumber, sort);
////            } else {
////                return analogRepository.findByPointNumber(pointNumber);
////            }
////        }
//        return analogRepository.findByPointNumber(pointNumber);
//    }
//
//    /**
//     * 根据设备代码和点号类型代码获得点表对象
//     * @param devCode 设备代码
//     * @param typeCode 点号类型代码
//     */
//    @Override
//    public Analog findAnalogsByDevCodeAndTypeCode(Long devCode, Long typeCode,String terminal,String meter) {
//        if(StringUtil.isEmpty(terminal)){
//            return analogRepository.findAnalogsByDevCodeAndTypeCode(devCode, typeCode);
//        }else if(!StringUtil.isEmpty(terminal)){
//            return analogRepository.findAnalogsByDevCodeAndTypeCodeAndTerminal(devCode, typeCode,terminal);
//        }else {
//            return analogRepository.findAnalogsByDevCodeAndTypeCodeAndMeter(devCode, typeCode,meter);
//        }
//
//    }
//
//    @Override
//    public List<Analog> findAnalogsByDevIdAndTypeCode(Long devId, Long typeCode, String terminal, String meter) {
//        if (!StringUtil.isEmpty(terminal)) {
//            return analogRepository.findAnalogsByDevIdAndTypeCodeAndTerminal(devId, typeCode, terminal);
//        } else if (!StringUtil.isEmpty(meter)) {
//            return analogRepository.findAnalogsByDevIdAndTypeCodeAndMeter(devId, typeCode, meter);
//        } else {
//            return analogRepository.findAnalogsByDevIdAndTypeCode(devId, typeCode);
//        }
//    }
//
//    @Override
//    public Iterable<Analog> findAnalogsByDevCodeAndTypeCode(List<Long> devCodeList, List<Long> typeCodeList) {
//        return analogRepository.findAnalogsByDevCodeAndTypeCode(devCodeList, typeCodeList);
//    }
//
//    /**
//     * 根据代码绑定点号数据类型
//     * @param code 点表代码
//     * @param pointDataTypeCode 点号数据类型代码
//     */
//    @Override
//    @Transactional
//    public void bindPointDataTypeByCode(Long code, Long pointDataTypeCode)
//            throws DatabaseProcessException {
//        analogRepository.bindPointDataTypeByCode(code, pointDataTypeCode);
//    }
//
//    /**
//     * 根据代码解绑点号数据类型
//     * @param code 点表代码
//     * @param pointDataTypeCode 点号数据类型代码
//     */
//    @Override
//    @Transactional
//    public void unbindPointDataTypeByCode(Long code, Long pointDataTypeCode)
//            throws DatabaseProcessException {
//        analogRepository.unbindPointDataTypeByCode(code, pointDataTypeCode);
//    }
//
//    /**
//     * 获取点表绑定的点号数据类型（根据代码）
//     * @param code
//     * @return
//     */
//    @Override
//    public Iterable<PointDataType> getPointDataTypeByCode(Long code) {
//        return analogRepository.getPointDataTypeByCode(code);
//    }
//
//    /**
//     * 更新点表绑定的点号数据类型（根据代码）
//     * @param code 代码
//     * @param pointDataTypeCodes 点号数据类型性代码
//     */
//    @Override
//    public void updatePointDataTypeByCode(Long code, List<Long> pointDataTypeCodes)
//            throws DatabaseProcessException {
//        analogRepository.unbindAllPointDataTypesByCode(code);
//        if (pointDataTypeCodes != null && pointDataTypeCodes.size() > 0) {
//            for (Long pointDataTypeCode : pointDataTypeCodes) {
//                analogRepository.bindPointDataTypeByCode(code, pointDataTypeCode);
//            }
//        }
//    }
//
//    /**
//     * 根据代码获取点表
//     * @param analogCode 点表code
//     * @return
//     */
//    @Override
//    public Analog getAnalogsByCode(Long analogCode)
//            throws ArgumentErrorException {
//        return analogRepository.findAnalogByCode(analogCode);
//    }
//
//    /**
//     * 修改点表（修改指定字段）
//     * @param code 点表代码
//     * @param name 点表编号
//     * @param title 标题
//     * @param pathName 路径名
//     * @param devCode 设备代码
//     * @param typeCode 点号数据类型代码
//     * @param pointNumber 点号
//     * @param transformRatio 倍率，默认1
//     * @param terminal 端子
//     * @param isForShow 是否用于展示
//     * @param upperLimit 上限值
//     * @param lowerLimit 下限值
//     */
//    @Override
//    @Transactional
//    public Analog updateAnalogByCode(Long code,
//                                     String name,
//                                     String title,
//                                     String pathName,
//                                     Long devCode,
//                                     Long typeCode,
//                                     Long pointNumber,
//                                     Double transformRatio,
//                                     String terminal,
//                                     String formula,
//                                     Boolean isForShow,
//                                     Double upperLimit,
//                                     Double lowerLimit,
//                                     String sn,
//                                     String officeName)
//            throws ArgumentErrorException, ObjectNotFoundException, UniqueConstraintsException {
//        Analog analog = this.findByCode(code);
//        if (analog == null) {
//            throw new ObjectNotFoundException("找不到代码为" + code + "的点表");
//        }
//        Optional.ofNullable(name).ifPresent(analog::setName);
//        Optional.ofNullable(title).ifPresent(analog::setTitle);
//        Optional.ofNullable(pathName).ifPresent(analog::setPathName);
//        Optional.ofNullable(pointNumber).ifPresent(analog::setPointNumber);
//        Optional.ofNullable(transformRatio).ifPresent(analog::setTransformRatio);
//        Optional.ofNullable(devCode).ifPresent(analog::setDevCode);
//        Optional.ofNullable(typeCode).ifPresent(analog::setTypeCode);
//        Optional.ofNullable(formula).ifPresent(analog::setFormula);
//        Optional.ofNullable(isForShow).ifPresent(analog::setForShow);
//        Optional.ofNullable(upperLimit).ifPresent(analog::setUpperLimit);
//        Optional.ofNullable(lowerLimit).ifPresent(analog::setLowerLimit);
//        Optional.ofNullable(sn).ifPresent(analog::setSn);
//        Optional.ofNullable(officeName).ifPresent(analog::setOfficeName);
//        processBeforeSave(analog);
//        analog.setTypeCode(null);
//        analog.setDevCode(null);
//        Analog newAnalog = analogRepository.save(analog);
//        if (devCode != null) {
//            analogRepository.unbindAnalogDevByCode(code);
//            analogRepository.bindDev(code, devCode, StringUtil.isEmpty(terminal)?null:terminal);
//        } else if (!StringUtil.isEmpty(terminal)) {
//            throw new ArgumentErrorException("请指定要修改的设备");
//        }
//        if (typeCode != null) {
//            analogRepository.unbindAnalogPointDataTypeByCode(code);
//            analogRepository.bindPointDataTypeByCode(code, typeCode);
//        }
//        if (StringUtils.isNotEmpty(officeName)) {
//            analogRepository.unbindOfficeByOfficeName(analog.getOfficeName(), code);
//            analogRepository.bindOfficeByOfficeName(officeName, code);
//        }
//
//        return newAnalog;
//    }
//
//    /**
//     * 根据设备代码获取设备的全部点表
//     * @param devCode 设备代码
//     * @param pointMeasureTypeCode
//     * @param isForShow
//     */
//    @Override
//    public Iterable<Analog> getAnalogsByDevCode(Long devCode,
//                                                Long pointMeasureTypeCode,
//                                                Boolean isForShow) {
//        Iterable<Analog> result;
//        if (isForShow != null) {
//            result = analogRepository.getAnalogsByDevCodeAndForShow(devCode, isForShow);
//        } else {
//            result = analogRepository.getAnalogsByDevCode(devCode);
//        }
//        Collections.sort((List<Analog>) result);
//        return result;
//    }
//
//    /**
//     * 根据设备ID查找点号
//     * @param devIdList 设备ID列表
//     */
//    @Override
//    public Iterable<Analog> findAnalogsByDevId(List<Long> devIdList) {
//        return analogRepository.findAnalogsByDevId(devIdList);
//    }
//
//    /**
//     * 根据设备ID和子设备标签以及点号类型获得点号列表
//     * @param deviceId 设备ID
//     * @param childType 子设备标签
//     * @param pdtCodeList 点号类型
//     */
//    @Override
//    public Iterable<Analog> findChildAnalogsDevIdAndType(Long deviceId,
//                                                         String childType,
//                                                         List<Long> pdtCodeList) {
//        return analogRepository.findChildAnalogsDevIdAndType(deviceId, childType, pdtCodeList);
//    }
//
//    /**
//     * 查找所有带公式的点号
//     */
//    @Override
//    public Iterable<Analog> findAnalogsByFormulaNotNull(){
//        return analogRepository.findAnalogsByFormulaNotNull();
//    }
//
//    @Override
//    public Iterable<Analog> findAnalogsByFirm(Long firmCode) {
//        return analogRepository.findAnalogsByFirm(firmCode);
//    }
//
//    @Override
//    public Iterable<Analog> findAnalogsByFormulaType(Long firmCode, String formulaType) {
//        return analogRepository.findAnalogsByFormulaType(firmCode, formulaType);
//    }
//
//    /**
//     * 根据采集频率查询点号
//     * @param frequency 采集频率
//     */
//    @Override
//    public Iterable<Analog> findAnalogsByFrequency(Integer frequency) {
//        return analogRepository.findAnalogsByFrequency(frequency);
//    }
//
//    /**
//     * 根据设备代码列表查询点表
//     * @param devCodeList 设备代码列表
//     */
//    @Override
//    public Iterable<Analog> findAnalogsByDevCodeList(List<Long> devCodeList) {
//        return analogRepository.findAnalogsByDevCodeList(devCodeList);
//    }
//
//    /**
//     * 根据电池组ID查询单体电池电压、温度点号
//     * @param packId 电池组ID
//     */
//    @Override
//    public List<Long> findBatteryPnByPackAndDataType(Long packId, List<Long> pointDataTypeCodeList) {
//        return analogRepository.findBatteryPnByPackAndDataType(packId, pointDataTypeCodeList);
//    }
//
//    @Override
//    public Map<Long, List<Long>> findCompanyPointNumber(Long firmId,
//                                                        Long stationId,
//                                                        Long companyId,
//                                                        Long typeCode,
//                                                        String terminal,
//                                                        String meter) {
//        return analogDao.findCompanyPointNumber(firmId, stationId, companyId, typeCode, terminal, meter);
//    }
//
//    @Override
//    public Map<Long, List<Long>> findStationPointNumber(Long firmId,
//                                                        Long stationId,
//                                                        Long typeCode,
//                                                        String terminal,
//                                                        String meter) {
//        return analogDao.findStationPointNumber(firmId, stationId, typeCode, terminal, meter);
//    }
//
//    @Override
//    public List<String> getMeterList(Long companyId,
//                                     String terminal) {
//        return analogDao.getMeterList(companyId, terminal);
//    }
//
//    @Override
//    public Iterable<Analog> searchByOfficeName(String officeName) {
//        return analogRepository.searchByOfficeName(officeName);
//    }
//}
